// #include <iostream>
// #include <sys/types.h>
// #include <sys/socket.h>
// #include <arpa/inet.h>
// #include <strings.h>
// #include <string.h>
// #include <unistd.h>
// #include <pthread.h>

// using namespace std;

// const uint16_t Serverport = 8081;
// const int backlog = 2;

// void* Routine(void* args)
// {
//     pthread_detach(pthread_self());
//     int fd = *(int*)args;

//     delete (int*)args;
//     while(true)
//     {
//         std::cout << "socket " << fd << " is serving the client" << std::endl;
//         sleep(1);
//     }

//     return nullptr;
// }

// int main()
// {
//     //创建套接字
//     int listensockfd = socket(AF_INET, SOCK_STREAM, 0);
//     if(listensockfd < 0)
//     {
//         perror("create sockfd fail!!!");
//         exit(-1);
//     }

//     int opt = 1;
//     setsockopt(listensockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

//     struct sockaddr_in Server;
//     // bzero(&Server, sizeof(Server));
//     memset(&Server, 0, sizeof(Server));
//     Server.sin_family = AF_INET;
//     Server.sin_addr.s_addr = INADDR_ANY;
//     Server.sin_port = htons(Serverport);
//     socklen_t len = sizeof(Server);

//     //bind
//     int n = bind(listensockfd, (const sockaddr*)&Server, len);
//     if(n < 0)
//     {
//         perror("bind fail!!!");
//         exit(-1);
//     }

//     //listen
//     if(listen(listensockfd, backlog) < 0)
//     {
//         perror("listen fail!!!");
//         exit(-1);
//     }
//     cout<<"success"<<endl;
//     struct sockaddr_in Client;
//     memset(&Client, 0, sizeof(Client));
//     len = sizeof(Client);
//     for(;;)
//     {
//         //accept
//         // int sockfd = accept(listensockfd, (struct sockaddr*)&Client, &len);
//         // cout << sockfd << endl;
//         // if(sockfd < 0) 
//         // {
//         //     cout << "try request connect" << endl;
//         //     continue;
//         // }
//         // cout<< "get a new link" << endl;
//         // pthread_t tid;
//         // //这里传递的是局部变量sockfd的地址，而这个变量在每次循环迭代时都会被重新使用。
//         // //当新的连接到来时，sockfd的值会被更新，而之前创建的线程可能还在使用这个地址，导致多个线程访问同一个内存地址的不同值，造成数据竞争和未定义行为。
//         // // pthread_create(&tid, nullptr, Routine, (void*)&sockfd); error: 会导致局部变量sockfd被重复使用

//         // //正确行为,给每一个服务套接字开辟一段空间，避免空间被重复利用
//         // int* p = new int(sockfd);
//         // pthread_create(&tid, nullptr, Routine, (void*)p); //注意线程库是第三方库，编译时需要指定库名
//     }

//     return 0;
// }

// #include <iostream>
// #include <cstring>
// #include <unistd.h>
// #include <sys/socket.h>
// #include <sys/types.h>
// #include <arpa/inet.h>
// #include <netinet/in.h>
// #include <pthread.h>

// const int port = 8081;
// const int num = 5;

// void* Routine(void* arg)
// {
// 	pthread_detach(pthread_self());
// 	int fd = *(int*)arg;
// 	delete (int*)arg;
// 	while (1){
// 		std::cout << "socket " << fd << " is serving the client" << std::endl;
// 		sleep(1);
// 	}

// 	return nullptr;
// }

// int main()
// {
// 	//创建监听套接字
// 	int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
// 	if (listen_sock < 0){
// 		std::cerr << "socket error" << std::endl;
// 		return 1;
// 	}
// 	//绑定
// 	struct sockaddr_in local;
// 	memset(&local, 0, sizeof(local));
// 	local.sin_port = htons(port);
// 	local.sin_family = AF_INET;
// 	local.sin_addr.s_addr = INADDR_ANY;

// 	if (bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0){
// 		std::cerr << "bind error" << std::endl;
// 		return 2;
// 	}
// 	//监听
// 	if (listen(listen_sock, num) < 0){
// 		std::cerr << "listen error" << std::endl;
// 		return 3;
// 	}
// 	//启动服务器
// 	struct sockaddr_in peer;
// 	memset(&peer, 0, sizeof(peer));
// 	socklen_t len = sizeof(peer);
	
// 	for (;;){
// 		int sock = accept(listen_sock, (struct sockaddr*)&peer, &len);
// 		if (sock < 0){
// 			std::cerr << "accept error" << std::endl;
// 			continue;
// 		}
// 		std::cout << "get a new link: " << sock << std::endl;
// 		int* p = new int(sock);
		
// 		pthread_t tid;
// 		pthread_create(&tid, nullptr, Routine, (void*)p);
// 	}
// 	return 0;
// }


#include <iostream>
#include <cstring>
#include <unistd.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <pthread.h>

const int port = 8081;
const int num = 1;

int main()
{
	//创建监听套接字
	int listen_sock = socket(AF_INET, SOCK_STREAM, 0);
	if (listen_sock < 0){
		std::cerr << "socket error" << std::endl;
		return 1;
	}
	int opt = 1;
	setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));
	//绑定
	struct sockaddr_in local;
	memset(&local, 0, sizeof(local));
	local.sin_port = htons(port);
	local.sin_family = AF_INET;
	local.sin_addr.s_addr = INADDR_ANY;
	
	if (bind(listen_sock, (struct sockaddr*)&local, sizeof(local)) < 0){
		std::cerr << "bind error" << std::endl;
		return 2;
	}
	//监听
	if (listen(listen_sock, num) < 0){
		std::cerr << "listen error" << std::endl;
		return 3;
	}
	//启动服务器
	for (;;){
		//不调用accept获取连接
        sleep(1);
	}
	return 0;
}
